Chip 2007 January, February, March & April/Chip-Cover-CD-2007-02.iso/Pakiet bezpieczenstwa/mini Pentoo LiveCD 2006.1/mpentoo-2006.1.iso/livecd.squashfs/usr/lib/python2.4/test/test_support.pyo

Python Compiled Bytecode | 2005-10-18 | 10KB | 335 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.4)

'''Supporting definitions for the Python regression tests.'''
if __name__ != 'test.test_support':
    raise ImportError, 'test_support must be imported from the test package'

import sys

class Error(Exception):
    '''Base class for regression test exceptions.'''
    pass


class TestFailed(Error):
    '''Test failed.'''
    pass


class TestSkipped(Error):
    """Test skipped.

    This can be raised to indicate that a test was deliberatly
    skipped, but not because a feature wasn't available.  For
    example, if some resource can't be used, such as the network
    appears to be unavailable, this should be raised instead of
    TestFailed.
    """
    pass


class ResourceDenied(TestSkipped):
    '''Test skipped because it requested a disallowed resource.

    This is raised when a test calls requires() for a resource that
    has not be enabled.  It is used to distinguish between expected
    and unexpected skips.
    '''
    pass

verbose = 1
use_resources = None
_original_stdout = None

def record_original_stdout(stdout):
    global _original_stdout
    _original_stdout = stdout


def get_original_stdout():
    if not _original_stdout:
        pass
    return sys.stdout


def unload(name):

    try:
        del sys.modules[name]
    except KeyError:
        pass



def forget(modname):
    '''"Forget" a module was ever imported by removing it from sys.modules and
    deleting any .pyc and .pyo files.'''
    unload(modname)
    import os as os
    for dirname in sys.path:

        try:
            os.unlink(os.path.join(dirname, modname + os.extsep + 'pyc'))
        except os.error:
            pass


        try:
            os.unlink(os.path.join(dirname, modname + os.extsep + 'pyo'))
        continue
        except os.error:
            continue





def is_resource_enabled(resource):
    '''Test whether a resource is enabled.  Known resources are set by
    regrtest.py.'''
    if use_resources is not None:
        pass
    return resource in use_resources


def requires(resource, msg = None):
    """Raise ResourceDenied if the specified resource is not available.

    If the caller's module is __main__ then automatically return True.  The
    possibility of False being returned occurs when regrtest.py is executing."""
    if sys._getframe().f_back.f_globals.get('__name__') == '__main__':
        return None

    if not is_resource_enabled(resource):
        if msg is None:
            msg = "Use of the `%s' resource not enabled" % resource

        raise ResourceDenied(msg)


FUZZ = 9.9999999999999995e-07

def fcmp(x, y):
    if type(x) == type(0.0) or type(y) == type(0.0):

        try:
            (x, y) = coerce(x, y)
            fuzz = (abs(x) + abs(y)) * FUZZ
            if abs(x - y) <= fuzz:
                return 0

    elif type(x) == type(y) and type(x) in (type(()), type([])):
        for i in range(min(len(x), len(y))):
            outcome = fcmp(x[i], y[i])
            if outcome != 0:
                return outcome
                continue

        return cmp(len(x), len(y))

    return cmp(x, y)


try:
    unicode
    have_unicode = 1
except NameError:
    have_unicode = 0

is_jython = sys.platform.startswith('java')
import os
if os.name == 'java':
    TESTFN = '$test'
elif os.name == 'riscos':
    TESTFN = 'testfile'
else:
    TESTFN = '@test'
    if have_unicode:
        if isinstance('', unicode):
            TESTFN_UNICODE = '@test-\xe0\xf2'
        else:
            TESTFN_UNICODE = unicode('@test-\xe0\xf2', 'latin-1')
        TESTFN_ENCODING = sys.getfilesystemencoding()
        if not hasattr(sys, 'getwindowsversion') or sys.getwindowsversion()[3] < 2:
            TESTFN_UNICODE_UNENCODEABLE = None
        else:
            TESTFN_UNICODE_UNENCODEABLE = eval('u"@test-\\u5171\\u6709\\u3055\\u308c\\u308b"')

            try:
                TESTFN_UNICODE_UNENCODEABLE.encode('Latin1')
            except UnicodeEncodeError:
                pass

            print 'WARNING: The filename %r CAN be encoded by the filesystem.  Unicode filename tests may not be effective' % TESTFN_UNICODE_UNENCODEABLE

fp = None

try:
    fp = open(TESTFN, 'w+')
except IOError:
    TMP_TESTFN = os.path.join('/tmp', TESTFN)

    try:
        fp = open(TMP_TESTFN, 'w+')
        TESTFN = TMP_TESTFN
        del TMP_TESTFN
    except IOError:
        print 'WARNING: tests will fail, unable to write to: %s or %s' % (TESTFN, TMP_TESTFN)
    except:
        None<EXCEPTION MATCH>IOError


    None<EXCEPTION MATCH>IOError

if fp is not None:
    fp.close()

    try:
        os.unlink(TESTFN)


del os
del fp
from os import unlink

def findfile(file, here = __file__):
    '''Try to find a file on sys.path and the working directory.  If it is not
    found the argument passed to the function is returned (this does not
    necessarily signal failure; could still be the legitimate path).'''
    import os
    if os.path.isabs(file):
        return file

    path = sys.path
    path = [
        os.path.dirname(here)] + path
    for dn in path:
        fn = os.path.join(dn, file)
        if os.path.exists(fn):
            return fn
            continue

    return file


def verify(condition, reason = 'test failed'):
    '''Verify that condition is true. If not, raise TestFailed.

       The optional argument reason can be given to provide
       a better error text.
    '''
    if not condition:
        raise TestFailed(reason)



def vereq(a, b):
    '''Raise TestFailed if a == b is false.

    This is better than verify(a == b) because, in case of failure, the
    error message incorporates repr(a) and repr(b) so you can see the
    inputs.

    Note that "not (a == b)" isn\'t necessarily the same as "a != b"; the
    former is tested.
    '''
    if not a == b:
        raise TestFailed, '%r == %r' % (a, b)



def sortdict(dict):
    '''Like repr(dict), but in sorted order.'''
    items = dict.items()
    items.sort()
    reprpairs = [ '%r: %r' % pair for pair in items ]
    withcommas = ', '.join(reprpairs)
    return '{%s}' % withcommas


def check_syntax(statement):

    try:
        compile(statement, '<string>', 'exec')
    except SyntaxError:
        pass

    print 'Missing SyntaxError: "%s"' % statement

import unittest

class BasicTestRunner:

    def run(self, test):
        result = unittest.TestResult()
        test(result)
        return result



def run_suite(suite, testclass = None):
    '''Run tests from a unittest.TestSuite-derived class.'''
    if verbose:
        runner = unittest.TextTestRunner(sys.stdout, verbosity = 2)
    else:
        runner = BasicTestRunner()
    result = runner.run(suite)
    if not result.wasSuccessful():
        if len(result.errors) == 1 and not (result.failures):
            err = result.errors[0][1]
        elif len(result.failures) == 1 and not (result.errors):
            err = result.failures[0][1]
        elif testclass is None:
            msg = 'errors occurred; run in verbose mode for details'
        else:
            msg = 'errors occurred in %s.%s' % (testclass.__module__, testclass.__name__)
        raise TestFailed(msg)
        raise TestFailed(err)



def run_unittest(*classes):
    '''Run tests from unittest.TestCase-derived classes.'''
    suite = unittest.TestSuite()
    for cls in classes:
        if isinstance(cls, (unittest.TestSuite, unittest.TestCase)):
            suite.addTest(cls)
            continue
        suite.addTest(unittest.makeSuite(cls))

    if len(classes) == 1:
        testclass = classes[0]
    else:
        testclass = None
    run_suite(suite, testclass)


def run_doctest(module, verbosity = None):
    """Run doctest on the given module.  Return (#failures, #tests).

    If optional argument verbosity is not specified (or is None), pass
    test_support's belief about verbosity on to doctest.  Else doctest's
    usual behavior is used (it searches sys.argv for -v).
    """
    import doctest as doctest
    if verbosity is None:
        verbosity = verbose
    else:
        verbosity = None
    save_stdout = sys.stdout
    sys.stdout = get_original_stdout()

    try:
        (f, t) = doctest.testmod(module, verbose = verbosity)
        if f:
            raise TestFailed('%d of %d doctests failed' % (f, t))
    finally:
        sys.stdout = save_stdout

    if verbose:
        print 'doctest (%s) ... %d tests with zero failures' % (module.__name__, t)

    return (f, t)